package o;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

public class auv<T> {
    final int ˋ;
    final Class<? super T> ˎ;
    final Type ॱ;

    protected auv() {
        this.ॱ = ˏ(getClass());
        this.ˎ = atp.ˏ(this.ॱ);
        this.ˋ = this.ॱ.hashCode();
    }

    auv(Type type) {
        this.ॱ = atp.ॱ((Type) atr.ˊ((Object) type));
        this.ˎ = atp.ˏ(this.ॱ);
        this.ˋ = this.ॱ.hashCode();
    }

    static Type ˏ(Class<?> cls) {
        Type genericSuperclass = cls.getGenericSuperclass();
        if (!(genericSuperclass instanceof Class)) {
            return atp.ॱ(((ParameterizedType) genericSuperclass).getActualTypeArguments()[0]);
        }
        throw new RuntimeException("Missing type parameter.");
    }

    public final Class<? super T> ˋ() {
        return this.ˎ;
    }

    public final Type ˏ() {
        return this.ॱ;
    }

    public final int hashCode() {
        return this.ˋ;
    }

    public final boolean equals(Object obj) {
        return (obj instanceof auv) && atp.ˊ(this.ॱ, ((auv) obj).ॱ);
    }

    public final String toString() {
        return atp.ʼ(this.ॱ);
    }

    public static auv<?> ˋ(Type type) {
        return new auv(type);
    }

    public static <T> auv<T> ˋ(Class<T> cls) {
        return new auv(cls);
    }
}
